<?php
/**
 * This code is licensed under the BSD 3-Clause License.
 *
 * Copyright (c) 2017, Maks Rafalko
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * * Neither the name of the copyright holder nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2021 Webmozarts GmbH
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

namespace Infection\Framework\Enum;

use function array_map;
use function array_search;
use function array_values;
use BackedEnum;
use function count;
use function get_debug_type;
use function implode;
use function in_array;
use InvalidArgumentException;
use OutOfBoundsException;
use function sprintf;

/**
 * @internal
 *
 * @template T of BackedEnum
 */
final class EnumBucket
{
    /**
     * @var array<string, T>
     */
    private array $values;

    /**
     * @param class-string<T> $enumClassName
     * @param array<string, T> $allValues
     */
    private function __construct(
        private readonly string $enumClassName,
        private readonly array $allValues,
    ) {
        $this->values = $this->allValues;
    }

    /**
     * @template E of BackedEnum
     *
     * @param class-string<E> $enumClassName
     *
     * @return self<E>
     */
    public static function create(string $enumClassName): self
    {
        return new self(
            $enumClassName,
            self::getCasesIndexedByName($enumClassName),
        );
    }

    /**
     * @param T $value
     *
     * @return T
     */
    public function take(mixed $value): mixed
    {
        $index = array_search($value, $this->values, true);

        if ($index === false) {
            $this->throwValueNotAvailable($value);
        }

        unset($this->values[$index]);

        return $value;
    }

    /**
     * @return list<T>
     */
    public function takeAll(): array
    {
        $values = $this->values;
        $this->values = [];

        return array_values($values);
    }

    public function isEmpty(): bool
    {
        return count($this->values) === 0;
    }

    public function assertIsEmpty(): void
    {
        if (!$this->isEmpty()) {
            throw $this->createBucketIsNotEmpty();
        }
    }

    /**
     * @template E of BackedEnum
     *
     * @param class-string<E> $backedEnumClassName
     *
     * @return array<string, E>
     */
    private static function getCasesIndexedByName(string $backedEnumClassName): array
    {
        $indexedValues = [];

        foreach ($backedEnumClassName::cases() as $case) {
            $indexedValues[$case->name] = $case;
        }

        return $indexedValues;
    }

    /**
     * @param T $value
     */
    private function throwValueNotAvailable(mixed $value): never
    {
        $indexInAllValues = in_array($value, $this->allValues, true);

        if ($indexInAllValues === false) {
            $this->asserValueIsANativeEnum($value);

            throw $this->createEnumValueDoesNotExist($value);
        }

        throw $this->createEnumValueNoLongerAvailable($value);
    }

    /**
     * @phpstan-assert BackedEnum $value
     * @psalm-assert BackedEnum $value
     */
    private function asserValueIsANativeEnum(mixed $value): void
    {
        if (!($value instanceof BackedEnum)) {
            throw $this->createExpectedValueToBeAnEnumException($value);
        }
    }

    private function createExpectedValueToBeAnEnumException(mixed $value): InvalidArgumentException
    {
        return new InvalidArgumentException(
            sprintf(
                'Expected value "%s" to be a case of the enum "%s".',
                get_debug_type($value),
                $this->enumClassName,
            ),
        );
    }

    private function createEnumValueDoesNotExist(mixed $value): InvalidArgumentException
    {
        /** @psalm-suppress InvalidArgument */
        return new InvalidArgumentException(
            sprintf(
                'The enum "%s" does not have a case "%s". Known names are: "%s".',
                $this->enumClassName,
                self::describeCase($value),
                implode(
                    '", "',
                    array_map(
                        self::describeCase(...),
                        $this->allValues,
                    ),
                ),
            ),
        );
    }

    private function createEnumValueNoLongerAvailable(mixed $value): OutOfBoundsException
    {
        /** @psalm-suppress InvalidArgument */
        return new OutOfBoundsException(
            sprintf(
                'The case "%s" is no longer available in the bucket. Available cases are: "%s".',
                self::describeCase($value),
                implode(
                    '", "',
                    array_map(
                        self::describeCase(...),
                        $this->values,
                    ),
                ),
            ),
        );
    }

    private function createBucketIsNotEmpty(): InvalidArgumentException
    {
        /** @psalm-suppress InvalidArgument */
        return new InvalidArgumentException(
            sprintf(
                'Expected the bucket to be empty. The following case(s) were found: "%s".',
                implode(
                    '", "',
                    array_map(
                        self::describeCase(...),
                        $this->values,
                    ),
                ),
            ),
        );
    }

    /**
     * @psalm-suppress UndefinedDocblockClass
     * @param BackedEnum&T $enum
     */
    private static function describeCase(BackedEnum $enum): string
    {
        return sprintf(
            '(name=%s,value=%s)',
            $enum->name,
            $enum->value,
        );
    }
}
